Il primo studio riguarda l'ottimizzazione della distribuzione dei dipartimenti sui livelli dellāedificio.
Compilazione della matrice delle prossimitĆ dei dipartimenti. Oltre alla matrice vengono inserite anche le aree di programma, le aree di progetto e lāindicazione dei livelli su cui possono essere ospitati i dipartimenti.
Lāalgoritmo generativo ĆØ la componente principale di tutto il processo. Eā lāinsieme di regole che consentono di creare le migliaia di opzioni, che poi verranno valutate ed esplorate nei passaggi successivi.
In questo caso ĆØ stato impostato uno script in Grasshopper in cui i valori assegnati alle variabili (sliders), generano composizioni di stacking ogni volta diverse.
Gli algoritmi di valutazione ricevono le opzioni dal generatore e, assegnando un valore, ne valutano la performance.
In questo caso vengono valutati tre parametri:
Il generative design engine, chiamato anche solver, ĆØ unāapplicazione software che esegue molte volte in automatico uno script, che contiene sia lāalgoritmo generativo che quello valutativo.
Variando più volte la posizione degli slider, ottiene una grande quantità di opzioni diverse e le relative valutazioni.
In questo caso sono stati utilizzati due metodi di generazione delle opzioni:

Optimize - Nella schermata si nota come l'algoritmo di ottimizzazione tenda a far convergere i valori dei parametri di valutazione verso i valori ottimali
Cross Product - Grafico a coordinate parallele
Cross Product - Scatter plot
La design space exploration (DSE) ĆØ un processo di analisi sistematica delle moltissime design option ottenute. Lāobiettivo ĆØ quello di analizzare i dati per una progressiva scrematura, fino a raggiungere un numero di opzioni accettabile e rappresentativo del design space.
La DSE può essere suddivisa in diversi step, in cui il numero di opzioni viene ridotto ad ogni passaggio.
Analisi dei dati eseguita con strumenti di programmazione Python e tecniche di unsupervised machine learning, che consentono di scremare le opzioni e selezionarne un numero ristretto.
%%javascript
$('.input').children('.inner_cell').hide();
# Import
import json
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
import seaborn as sns
from sklearn import metrics
import plotly
import plotly.graph_objects as go
import plotly.express as px
projectName = "BPVC"
# Dataframe from GD Autodesk
df = pd.read_csv('../DSE/000000-CVP-CD-01-X-DY-Departments 012.csv')
studyName = "GD012"
# Dataframe from Wallacei
#df = pd.read_excel('../DSE/BPVC-WLC Results.xlsx')
#studyName = "WLC"
df
Gli strumenti utilizzati sono:
fig = go.Figure(data=
go.Parcoords(labelfont = {'family': "Arial",
'size': 14
},
line = dict(color = df['posAdj'],
colorscale = 'tealrose',
showscale = True,
colorbar = {'tickfont': {'size': 14
}
},
),
dimensions = list([
dict(label = "Adjacency", values = df['posAdj']),
dict(label = 'Remote', values = df['negAdj']),
dict(label = 'Departments Leftover Area', values = df['depLeftoverArea']),
#dict(label = 'Levels Leftover Area', values = df['levLeftoverArea'])
])
),
)
fig.show()
df_ToCluster = df.loc[(df['posAdj'] >= 150) & (df['negAdj'] >= -80)]
df_ToCluster = df_ToCluster[['posAdj','negAdj','depLeftoverArea']]
sns.set()
sns_plot = sns.pairplot(df_ToCluster)
scaler = StandardScaler()
scaled_array = scaler.fit_transform(df_ToCluster)
scaled_dataframe = pd.DataFrame( scaled_array, columns = df_ToCluster.columns )
kmeans_model = KMeans(n_clusters = 10)
kmeans_model.fit(scaled_dataframe)
df_ToCluster["cluster"] = kmeans_model.labels_
scaled_dataframe["cluster"] = kmeans_model.labels_
fig = go.Figure(data=[go.Scatter3d(
x=df_ToCluster['posAdj'],
y=df_ToCluster['negAdj'],
z=df_ToCluster['depLeftoverArea'],
mode='markers',
marker=dict(
size=12,
color=df_ToCluster['cluster'], # set color to an array/list of desired values
colorscale='geyser', # choose a colorscale
opacity=0.8,
colorbar = {'tickvals': df_ToCluster['cluster'].tolist(),
'ticktext': df_ToCluster['cluster'].tolist(),
'tickfont': {'size': 14},
},
))])
fig.update_layout(scene = dict(
xaxis_title='Sun Exposure',
yaxis_title='View to Park',
zaxis_title='Summer Rad RS'),
margin=dict(l=0, r=0, b=0, t=0))
fig.show()
sns.set()
sns_plot = sns.pairplot(data = df_ToCluster, hue = "cluster", palette = "Spectral")
Esplorazione delle singole opzioni
</div>
</div>
Dopo aver impostato lo stacking e di conseguenza il posizionamento dei dipartimenti su ogni livello, stiamo studiando un workflow che agevoli lo space planning dei piani.
Come giĆ fatto per i dipartimenti, viene compilata la matrice delle adiacenze, per le funzioni di piano.
</div>
</div>
Abbiamo sperimentato diversi metodi che generano in automatico un grafico a bolle che massimizza la vicinanza dei nodi collegati tra di loro.
</div>
</div>
%%javascript
function toggler(){
if(window.already_toggling){
// Don't add multiple buttons.
return 0
}
let btn = $('.input').append('<button>Toggle Code</button>')
.children('button');
$('.input').children('.inner_cell').hide();
btn.on('click', function(e){
let tgt = e.currentTarget;
$(tgt).parent().children('.inner_cell').toggle()
})
window.already_toggling = true;
}
setTimeout(toggler, 5000);
!jupyter nbconvert BPVC-Report.ipynb --to html --template classic